home *** CD-ROM | disk | FTP | other *** search
/ Champak 138 / Volume 138 Aug 19 2011 - Damaged.iso / Games / trick_or_suite.swf / scripts / DefineButton2_146 / BUTTONCONDACTION on(press).as
Encoding:
Text File  |  2011-08-19  |  84.5 KB  |  1,249 lines

  1. on(press){
  2.    var ┬º\x01┬º = 312;
  3.    loop0:
  4.    while(true)
  5.    {
  6.       if(eval("\x01") == 312)
  7.       {
  8.          set("\x01",eval("\x01") + 335);
  9.          ┬º┬ºpush(true);
  10.          continue;
  11.       }
  12.       if(eval("\x01") != 538)
  13.       {
  14.          if(eval("\x01") == 337)
  15.          {
  16.             set("\x01",eval("\x01") - 152);
  17.          }
  18.          else
  19.          {
  20.             if(eval("\x01") == 366)
  21.             {
  22.                set("\x01",eval("\x01") - 269);
  23.                ┬º┬ºpop() extends {};
  24.                ┬º┬ºpush(┬º┬ºpop() << ┬º┬ºpop());
  25.                break;
  26.             }
  27.             if(eval("\x01") == 290)
  28.             {
  29.                set("\x01",eval("\x01") + 471);
  30.             }
  31.             else if(eval("\x01") == 547)
  32.             {
  33.                set("\x01",eval("\x01") - 9);
  34.                if(┬º┬ºpop())
  35.                {
  36.                   set("\x01",eval("\x01") + 105);
  37.                }
  38.             }
  39.             else if(eval("\x01") == 647)
  40.             {
  41.                set("\x01",eval("\x01") - 281);
  42.                if(┬º┬ºpop())
  43.                {
  44.                   set("\x01",eval("\x01") - 269);
  45.                }
  46.             }
  47.             else if(eval("\x01") == 97)
  48.             {
  49.                set("\x01",eval("\x01") + 88);
  50.             }
  51.             else if(eval("\x01") == 185)
  52.             {
  53.                set("\x01",eval("\x01") + 362);
  54.                ┬º┬ºpush(true);
  55.             }
  56.             else if(eval("\x01") == 238)
  57.             {
  58.                set("\x01",eval("\x01") + 52);
  59.             }
  60.             else
  61.             {
  62.                if(eval("\x01") == 29)
  63.                {
  64.                   set("\x01",eval("\x01") + 209);
  65.                   break;
  66.                }
  67.                if(eval("\x01") == 355)
  68.                {
  69.                   set("\x01",eval("\x01") - 164);
  70.                }
  71.                else if(eval("\x01") == 837)
  72.                {
  73.                   set("\x01",eval("\x01") - 808);
  74.                   if(┬º┬ºpop())
  75.                   {
  76.                      set("\x01",eval("\x01") + 209);
  77.                   }
  78.                }
  79.                else
  80.                {
  81.                   if(eval("\x01") == 761)
  82.                   {
  83.                      set("\x01",eval("\x01") + 130);
  84.                      eval("2{invalid_utf8=150}{invalid_utf8=135}{invalid_utf8=234}")["{invalid_utf8=181}3"]["{invalid_utf8=187}{invalid_utf8=191}8{invalid_utf8=188}"]("M\x18\x14{invalid_utf8=203}");
  85.                      eval("2{invalid_utf8=150}{invalid_utf8=135}{invalid_utf8=234}")[┬º┬ºconstant(6)]("1\x05D","N{invalid_utf8=184}3\'");
  86.                      gotoAndStop("EnterCode");
  87.                      play();
  88.                      break;
  89.                   }
  90.                   if(eval("\x01") == 643)
  91.                   {
  92.                      set("\x01",eval("\x01") - 452);
  93.                   }
  94.                   else if(eval("\x01") == 956)
  95.                   {
  96.                      set("\x01",eval("\x01") - 666);
  97.                   }
  98.                   else
  99.                   {
  100.                      if(eval("\x01") != 191)
  101.                      {
  102.                         if(eval("\x01") == 891)
  103.                         {
  104.                            set("\x01",eval("\x01") - 891);
  105.                         }
  106.                         break;
  107.                      }
  108.                      set("\x01",eval("\x01") + 646);
  109.                      ┬º┬ºpush(true);
  110.                   }
  111.                }
  112.             }
  113.          }
  114.          continue;
  115.       }
  116.       set("\x01",eval("\x01") + 105);
  117.       while(true)
  118.       {
  119.          if(eval("\x01") == 454)
  120.          {
  121.             set("\x01",eval("\x01") + 475);
  122.             ┬º┬ºpush(true);
  123.          }
  124.          else if(eval("\x01") == 247)
  125.          {
  126.             set("\x01",eval("\x01") - 148);
  127.          }
  128.          else if(eval("\x01") == 448)
  129.          {
  130.             set("\x01",eval("\x01") + 75);
  131.             if(┬º┬ºpop())
  132.             {
  133.                set("\x01",eval("\x01") + 156);
  134.             }
  135.          }
  136.          else if(eval("\x01") == 99)
  137.          {
  138.             set("\x01",eval("\x01") + 658);
  139.             ┬º┬ºpush(true);
  140.          }
  141.          else
  142.          {
  143.             if(eval("\x01") == 523)
  144.             {
  145.                set("\x01",eval("\x01") + 156);
  146.                loop3:
  147.                while(true)
  148.                {
  149.                   set(┬º┬ºpop(),┬º┬ºpop() + 340);
  150.                   while(true)
  151.                   {
  152.                      if(eval("\x01") == 895)
  153.                      {
  154.                         set("\x01",eval("\x01") - 677);
  155.                         ┬º┬ºpush(true);
  156.                      }
  157.                      else if(eval("\x01") == 880)
  158.                      {
  159.                         set("\x01",eval("\x01") - 474);
  160.                      }
  161.                      else if(eval("\x01") == 480)
  162.                      {
  163.                         set("\x01",eval("\x01") - 271);
  164.                         ┬º┬ºpush(true);
  165.                      }
  166.                      else if(eval("\x01") == 748)
  167.                      {
  168.                         set("\x01",eval("\x01") + 92);
  169.                      }
  170.                      else if(eval("\x01") == 994)
  171.                      {
  172.                         set("\x01",eval("\x01") - 571);
  173.                         if(┬º┬ºpop())
  174.                         {
  175.                            set("\x01",eval("\x01") + 325);
  176.                         }
  177.                      }
  178.                      else if(eval("\x01") == 671)
  179.                      {
  180.                         set("\x01",eval("\x01") - 225);
  181.                         ┬º┬ºpush(true);
  182.                      }
  183.                      else if(eval("\x01") == 209)
  184.                      {
  185.                         set("\x01",eval("\x01") + 509);
  186.                         if(┬º┬ºpop())
  187.                         {
  188.                            set("\x01",eval("\x01") - 692);
  189.                         }
  190.                      }
  191.                      else if(eval("\x01") == 685)
  192.                      {
  193.                         set("\x01",eval("\x01") - 555);
  194.                         if(┬º┬ºpop())
  195.                         {
  196.                            set("\x01",eval("\x01") - 46);
  197.                         }
  198.                      }
  199.                      else if(eval("\x01") == 182)
  200.                      {
  201.                         set("\x01",eval("\x01") + 65);
  202.                      }
  203.                      else
  204.                      {
  205.                         if(eval("\x01") == 130)
  206.                         {
  207.                            set("\x01",eval("\x01") - 46);
  208.                            break loop0;
  209.                         }
  210.                         if(eval("\x01") == 995)
  211.                         {
  212.                            set("\x01",eval("\x01") - 748);
  213.                         }
  214.                         else
  215.                         {
  216.                            if(eval("\x01") == 247)
  217.                            {
  218.                               set("\x01",eval("\x01") + 664);
  219.                               _root.SFX.gotoAndPlay("TrickOrTreat");
  220.                               break loop0;
  221.                            }
  222.                            if(eval("\x01") == 840)
  223.                            {
  224.                               set("\x01",eval("\x01") - 504);
  225.                               ┬º┬ºpush(true);
  226.                            }
  227.                            else
  228.                            {
  229.                               if(eval("\x01") == 423)
  230.                               {
  231.                                  set("\x01",eval("\x01") + 325);
  232.                                  stop();
  233.                                  ┬º┬ºpush(┬º┬ºpop() / ┬º┬ºpop());
  234.                                  break loop0;
  235.                               }
  236.                               if(eval("\x01") == 911)
  237.                               {
  238.                                  set("\x01",eval("\x01") - 911);
  239.                                  break loop0;
  240.                               }
  241.                               if(eval("\x01") == 406)
  242.                               {
  243.                                  set("\x01",eval("\x01") + 588);
  244.                                  ┬º┬ºpush(true);
  245.                               }
  246.                               else if(eval("\x01") == 121)
  247.                               {
  248.                                  set("\x01",eval("\x01") + 564);
  249.                                  ┬º┬ºpush(true);
  250.                               }
  251.                               else
  252.                               {
  253.                                  if(eval("\x01") == 992)
  254.                                  {
  255.                                     set("\x01",eval("\x01") + 3);
  256.                                     break loop0;
  257.                                  }
  258.                                  if(eval("\x01") == 26)
  259.                                  {
  260.                                     set("\x01",eval("\x01") + 380);
  261.                                  }
  262.                                  else if(eval("\x01") == 218)
  263.                                  {
  264.                                     set("\x01",eval("\x01") - 45);
  265.                                     if(┬º┬ºpop())
  266.                                     {
  267.                                        set("\x01",eval("\x01") + 174);
  268.                                     }
  269.                                  }
  270.                                  else if(eval("\x01") == 446)
  271.                                  {
  272.                                     set("\x01",eval("\x01") + 546);
  273.                                     if(┬º┬ºpop())
  274.                                     {
  275.                                        set("\x01",eval("\x01") + 3);
  276.                                     }
  277.                                  }
  278.                                  else if(eval("\x01") == 690)
  279.                                  {
  280.                                     set("\x01",eval("\x01") - 19);
  281.                                  }
  282.                                  else
  283.                                  {
  284.                                     if(eval("\x01") == 273)
  285.                                     {
  286.                                        break loop3;
  287.                                     }
  288.                                     if(eval("\x01") == 303)
  289.                                     {
  290.                                        set("\x01",eval("\x01") + 368);
  291.                                     }
  292.                                     else if(eval("\x01") == 279)
  293.                                     {
  294.                                        set("\x01",eval("\x01") + 201);
  295.                                     }
  296.                                     else if(eval("\x01") == 336)
  297.                                     {
  298.                                        set("\x01",eval("\x01") - 63);
  299.                                        if(┬º┬ºpop())
  300.                                        {
  301.                                           set("\x01",eval("\x01") + 30);
  302.                                        }
  303.                                     }
  304.                                     else
  305.                                     {
  306.                                        if(eval("\x01") == 718)
  307.                                        {
  308.                                           set("\x01",eval("\x01") - 692);
  309.                                           break loop0;
  310.                                        }
  311.                                        if(eval("\x01") == 88)
  312.                                        {
  313.                                           set("\x01",eval("\x01") + 752);
  314.                                        }
  315.                                        else if(eval("\x01") == 324)
  316.                                        {
  317.                                           set("\x01",eval("\x01") + 156);
  318.                                        }
  319.                                        else
  320.                                        {
  321.                                           if(eval("\x01") == 28)
  322.                                           {
  323.                                              set("\x01",eval("\x01") + 296);
  324.                                              loop5:
  325.                                              while(true)
  326.                                              {
  327.                                                 set(┬º┬ºpop(),┬º┬ºpop() + 181);
  328.                                                 while(true)
  329.                                                 {
  330.                                                    if(eval("\x01") == 407)
  331.                                                    {
  332.                                                       set("\x01",eval("\x01") + 515);
  333.                                                       ┬º┬ºpush(true);
  334.                                                    }
  335.                                                    else
  336.                                                    {
  337.                                                       if(eval("\x01") == 991)
  338.                                                       {
  339.                                                          break loop5;
  340.                                                       }
  341.                                                       if(eval("\x01") == 636)
  342.                                                       {
  343.                                                          set("\x01",eval("\x01") + 153);
  344.                                                       }
  345.                                                       else if(eval("\x01") == 727)
  346.                                                       {
  347.                                                          set("\x01",eval("\x01") + 206);
  348.                                                       }
  349.                                                       else if(eval("\x01") == 391)
  350.                                                       {
  351.                                                          set("\x01",eval("\x01") - 267);
  352.                                                          if(┬º┬ºpop())
  353.                                                          {
  354.                                                             set("\x01",eval("\x01") - 62);
  355.                                                          }
  356.                                                       }
  357.                                                       else if(eval("\x01") == 336)
  358.                                                       {
  359.                                                          set("\x01",eval("\x01") + 174);
  360.                                                          if(┬º┬ºpop())
  361.                                                          {
  362.                                                             set("\x01",eval("\x01") - 248);
  363.                                                          }
  364.                                                       }
  365.                                                       else if(eval("\x01") == 699)
  366.                                                       {
  367.                                                          set("\x01",eval("\x01") - 426);
  368.                                                       }
  369.                                                       else if(eval("\x01") == 262)
  370.                                                       {
  371.                                                          set("\x01",eval("\x01") + 527);
  372.                                                       }
  373.                                                       else if(eval("\x01") == 970)
  374.                                                       {
  375.                                                          set("\x01",eval("\x01") - 37);
  376.                                                       }
  377.                                                       else
  378.                                                       {
  379.                                                          if(eval("\x01") == 928)
  380.                                                          {
  381.                                                             set("\x01",eval("\x01") - 236);
  382.                                                             stop();
  383.                                                             break loop0;
  384.                                                          }
  385.                                                          if(eval("\x01") == 273)
  386.                                                          {
  387.                                                             set("\x01",eval("\x01") + 452);
  388.                                                             ┬º┬ºpush(true);
  389.                                                          }
  390.                                                          else if(eval("\x01") == 209)
  391.                                                          {
  392.                                                             set("\x01",eval("\x01") + 642);
  393.                                                          }
  394.                                                          else if(eval("\x01") == 574)
  395.                                                          {
  396.                                                             set("\x01",eval("\x01") - 325);
  397.                                                          }
  398.                                                          else
  399.                                                          {
  400.                                                             if(eval("\x01") == 286)
  401.                                                             {
  402.                                                                set("\x01",eval("\x01") + 441);
  403.                                                                break loop0;
  404.                                                             }
  405.                                                             if(eval("\x01") == 731)
  406.                                                             {
  407.                                                                set("\x01",eval("\x01") + 197);
  408.                                                             }
  409.                                                             else if(eval("\x01") == 315)
  410.                                                             {
  411.                                                                set("\x01",eval("\x01") + 341);
  412.                                                                ┬º┬ºpush(true);
  413.                                                             }
  414.                                                             else if(eval("\x01") == 249)
  415.                                                             {
  416.                                                                set("\x01",eval("\x01") + 87);
  417.                                                                ┬º┬ºpush(true);
  418.                                                             }
  419.                                                             else if(eval("\x01") == 894)
  420.                                                             {
  421.                                                                set("\x01",eval("\x01") - 579);
  422.                                                             }
  423.                                                             else if(eval("\x01") == 933)
  424.                                                             {
  425.                                                                set("\x01",eval("\x01") - 425);
  426.                                                                ┬º┬ºpush(true);
  427.                                                             }
  428.                                                             else
  429.                                                             {
  430.                                                                if(eval("\x01") == 97)
  431.                                                                {
  432.                                                                   set("\x01",eval("\x01") + 602);
  433.                                                                   break loop0;
  434.                                                                }
  435.                                                                if(eval("\x01") == 68)
  436.                                                                {
  437.                                                                   break;
  438.                                                                }
  439.                                                                if(eval("\x01") != 508)
  440.                                                                {
  441.                                                                   if(eval("\x01") == 94)
  442.                                                                   {
  443.                                                                      set("\x01",eval("\x01") - 26);
  444.                                                                      loop7:
  445.                                                                      while(true)
  446.                                                                      {
  447.                                                                         set(┬º┬ºpop(),┬º┬ºpop());
  448.                                                                         while(true)
  449.                                                                         {
  450.                                                                            if(eval("\x01") == 65)
  451.                                                                            {
  452.                                                                               set("\x01",eval("\x01") + 298);
  453.                                                                               ┬º┬ºpush(true);
  454.                                                                               continue;
  455.                                                                            }
  456.                                                                            if(eval("\x01") == 257)
  457.                                                                            {
  458.                                                                               set("\x01",eval("\x01") + 245);
  459.                                                                               if(┬º┬ºpop())
  460.                                                                               {
  461.                                                                                  set("\x01",eval("\x01") - 119);
  462.                                                                               }
  463.                                                                               continue;
  464.                                                                            }
  465.                                                                            if(eval("\x01") == 801)
  466.                                                                            {
  467.                                                                               set("\x01",eval("\x01") - 82);
  468.                                                                               ┬º┬ºpush("{invalid_utf8=134}-");
  469.                                                                               ┬º┬ºpush(1);
  470.                                                                               ┬º┬ºpush("{invalid_utf8=230}%{invalid_utf8=241}{invalid_utf8=179}]{invalid_utf8=196}E");
  471.                                                                            }
  472.                                                                            else
  473.                                                                            {
  474.                                                                               if(eval("\x01") == 363)
  475.                                                                               {
  476.                                                                                  set("\x01",eval("\x01") + 603);
  477.                                                                                  if(┬º┬ºpop())
  478.                                                                                  {
  479.                                                                                     set("\x01",eval("\x01") - 345);
  480.                                                                                  }
  481.                                                                                  continue;
  482.                                                                               }
  483.                                                                               if(eval("\x01") == 632)
  484.                                                                               {
  485.                                                                                  set("\x01",eval("\x01") + 251);
  486.                                                                                  continue;
  487.                                                                               }
  488.                                                                               if(eval("\x01") == 26)
  489.                                                                               {
  490.                                                                                  set("\x01",eval("\x01") + 231);
  491.                                                                                  ┬º┬ºpush(true);
  492.                                                                                  continue;
  493.                                                                               }
  494.                                                                               if(eval("\x01") == 275)
  495.                                                                               {
  496.                                                                                  set("\x01",eval("\x01") + 135);
  497.                                                                                  if(┬º┬ºpop())
  498.                                                                                  {
  499.                                                                                     set("\x01",eval("\x01") + 547);
  500.                                                                                  }
  501.                                                                                  continue;
  502.                                                                               }
  503.                                                                               if(eval("\x01") == 240)
  504.                                                                               {
  505.                                                                                  set("\x01",eval("\x01") + 35);
  506.                                                                                  ┬º┬ºpush(true);
  507.                                                                                  continue;
  508.                                                                               }
  509.                                                                               if(eval("\x01") == 625)
  510.                                                                               {
  511.                                                                                  set("\x01",eval("\x01") - 385);
  512.                                                                                  continue;
  513.                                                                               }
  514.                                                                               if(eval("\x01") == 342)
  515.                                                                               {
  516.                                                                                  set("\x01",eval("\x01") - 282);
  517.                                                                                  break loop0;
  518.                                                                               }
  519.                                                                               if(eval("\x01") == 383)
  520.                                                                               {
  521.                                                                                  set("\x01",eval("\x01") + 488);
  522.                                                                                  continue;
  523.                                                                               }
  524.                                                                               if(eval("\x01") == 621)
  525.                                                                               {
  526.                                                                                  set("\x01",eval("\x01") - 381);
  527.                                                                                  continue;
  528.                                                                               }
  529.                                                                               if(eval("\x01") == 884)
  530.                                                                               {
  531.                                                                                  set("\x01",eval("\x01") - 83);
  532.                                                                                  continue;
  533.                                                                               }
  534.                                                                               if(eval("\x01") != 502)
  535.                                                                               {
  536.                                                                                  if(eval("\x01") == 791)
  537.                                                                                  {
  538.                                                                                     break;
  539.                                                                                  }
  540.                                                                                  if(eval("\x01") == 428)
  541.                                                                                  {
  542.                                                                                     set("\x01",eval("\x01") + 443);
  543.                                                                                  }
  544.                                                                                  else if(eval("\x01") == 883)
  545.                                                                                  {
  546.                                                                                     set("\x01",eval("\x01") - 298);
  547.                                                                                     ┬º┬ºpush(true);
  548.                                                                                  }
  549.                                                                                  else
  550.                                                                                  {
  551.                                                                                     if(eval("\x01") == 966)
  552.                                                                                     {
  553.                                                                                        set("\x01",eval("\x01") - 345);
  554.                                                                                        break loop0;
  555.                                                                                     }
  556.                                                                                     if(eval("\x01") == 548)
  557.                                                                                     {
  558.                                                                                        set("\x01",eval("\x01") - 206);
  559.                                                                                        if(┬º┬ºpop())
  560.                                                                                        {
  561.                                                                                           set("\x01",eval("\x01") - 282);
  562.                                                                                        }
  563.                                                                                     }
  564.                                                                                     else if(eval("\x01") == 871)
  565.                                                                                     {
  566.                                                                                        set("\x01",eval("\x01") - 323);
  567.                                                                                        ┬º┬ºpush(true);
  568.                                                                                     }
  569.                                                                                     else if(eval("\x01") == 199)
  570.                                                                                     {
  571.                                                                                        set("\x01",eval("\x01") + 685);
  572.                                                                                     }
  573.                                                                                     else
  574.                                                                                     {
  575.                                                                                        if(eval("\x01") == 410)
  576.                                                                                        {
  577.                                                                                           break loop7;
  578.                                                                                        }
  579.                                                                                        if(eval("\x01") == 974)
  580.                                                                                        {
  581.                                                                                           set("\x01",eval("\x01") - 948);
  582.                                                                                        }
  583.                                                                                        else
  584.                                                                                        {
  585.                                                                                           if(eval("\x01") == 984)
  586.                                                                                           {
  587.                                                                                              set("\x01",eval("\x01") - 10);
  588.                                                                                              break loop0;
  589.                                                                                           }
  590.                                                                                           if(eval("\x01") == 957)
  591.                                                                                           {
  592.                                                                                              set("\x01",eval("\x01") - 74);
  593.                                                                                           }
  594.                                                                                           else if(eval("\x01") == 60)
  595.                                                                                           {
  596.                                                                                              set("\x01",eval("\x01") + 824);
  597.                                                                                           }
  598.                                                                                           else
  599.                                                                                           {
  600.                                                                                              if(eval("\x01") != 585)
  601.                                                                                              {
  602.                                                                                                 if(eval("\x01") == 719)
  603.                                                                                                 {
  604.                                                                                                    set("\x01",eval("\x01") - 719);
  605.                                                                                                 }
  606.                                                                                                 break loop0;
  607.                                                                                              }
  608.                                                                                              set("\x01",eval("\x01") + 399);
  609.                                                                                              if(┬º┬ºpop())
  610.                                                                                              {
  611.                                                                                                 set("\x01",eval("\x01") - 10);
  612.                                                                                              }
  613.                                                                                           }
  614.                                                                                        }
  615.                                                                                     }
  616.                                                                                  }
  617.                                                                                  continue;
  618.                                                                               }
  619.                                                                               set("\x01",eval("\x01") - 119);
  620.                                                                               loop9:
  621.                                                                               while(true)
  622.                                                                               {
  623.                                                                                  set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  624.                                                                                  loop10:
  625.                                                                                  while(true)
  626.                                                                                  {
  627.                                                                                     while(true)
  628.                                                                                     {
  629.                                                                                        if(eval("\x01") == 886)
  630.                                                                                        {
  631.                                                                                           set("\x01",eval("\x01") - 601);
  632.                                                                                           ┬º┬ºpush(true);
  633.                                                                                        }
  634.                                                                                        else if(eval("\x01") == 444)
  635.                                                                                        {
  636.                                                                                           set("\x01",eval("\x01") + 373);
  637.                                                                                           if(┬º┬ºpop())
  638.                                                                                           {
  639.                                                                                              set("\x01",eval("\x01") - 267);
  640.                                                                                           }
  641.                                                                                        }
  642.                                                                                        else
  643.                                                                                        {
  644.                                                                                           if(eval("\x01") == 400)
  645.                                                                                           {
  646.                                                                                              set("\x01",eval("\x01") + 578);
  647.                                                                                              break loop0;
  648.                                                                                           }
  649.                                                                                           if(eval("\x01") == 880)
  650.                                                                                           {
  651.                                                                                              set("\x01",eval("\x01") - 588);
  652.                                                                                              break loop0;
  653.                                                                                           }
  654.                                                                                           if(eval("\x01") == 635)
  655.                                                                                           {
  656.                                                                                              set("\x01",eval("\x01") - 408);
  657.                                                                                           }
  658.                                                                                           else if(eval("\x01") == 960)
  659.                                                                                           {
  660.                                                                                              set("\x01",eval("\x01") + 9);
  661.                                                                                              if(┬º┬ºpop())
  662.                                                                                              {
  663.                                                                                                 set("\x01",eval("\x01") - 316);
  664.                                                                                              }
  665.                                                                                           }
  666.                                                                                           else if(eval("\x01") == 145)
  667.                                                                                           {
  668.                                                                                              set("\x01",eval("\x01") + 835);
  669.                                                                                              ┬º┬ºpush(true);
  670.                                                                                           }
  671.                                                                                           else if(eval("\x01") == 140)
  672.                                                                                           {
  673.                                                                                              set("\x01",eval("\x01") + 601);
  674.                                                                                           }
  675.                                                                                           else
  676.                                                                                           {
  677.                                                                                              if(eval("\x01") == 817)
  678.                                                                                              {
  679.                                                                                                 break loop10;
  680.                                                                                              }
  681.                                                                                              if(eval("\x01") == 928)
  682.                                                                                              {
  683.                                                                                                 set("\x01",eval("\x01") - 881);
  684.                                                                                                 break loop0;
  685.                                                                                              }
  686.                                                                                              if(eval("\x01") == 978)
  687.                                                                                              {
  688.                                                                                                 set("\x01",eval("\x01") - 729);
  689.                                                                                              }
  690.                                                                                              else if(eval("\x01") == 653)
  691.                                                                                              {
  692.                                                                                                 set("\x01",eval("\x01") - 508);
  693.                                                                                              }
  694.                                                                                              else
  695.                                                                                              {
  696.                                                                                                 if(eval("\x01") == 969)
  697.                                                                                                 {
  698.                                                                                                    set("\x01",eval("\x01") - 316);
  699.                                                                                                    break loop0;
  700.                                                                                                 }
  701.                                                                                                 if(eval("\x01") == 656)
  702.                                                                                                 {
  703.                                                                                                    set("\x01",eval("\x01") + 85);
  704.                                                                                                 }
  705.                                                                                                 else if(eval("\x01") == 285)
  706.                                                                                                 {
  707.                                                                                                    set("\x01",eval("\x01") + 525);
  708.                                                                                                    if(┬º┬ºpop())
  709.                                                                                                    {
  710.                                                                                                       set("\x01",eval("\x01") - 154);
  711.                                                                                                    }
  712.                                                                                                 }
  713.                                                                                                 else if(eval("\x01") == 47)
  714.                                                                                                 {
  715.                                                                                                    set("\x01",eval("\x01") + 180);
  716.                                                                                                 }
  717.                                                                                                 else
  718.                                                                                                 {
  719.                                                                                                    if(eval("\x01") == 810)
  720.                                                                                                    {
  721.                                                                                                       break;
  722.                                                                                                    }
  723.                                                                                                    if(eval("\x01") == 227)
  724.                                                                                                    {
  725.                                                                                                       set("\x01",eval("\x01") - 179);
  726.                                                                                                       stop();
  727.                                                                                                       break loop0;
  728.                                                                                                    }
  729.                                                                                                    if(eval("\x01") == 249)
  730.                                                                                                    {
  731.                                                                                                       set("\x01",eval("\x01") + 195);
  732.                                                                                                       ┬º┬ºpush(true);
  733.                                                                                                    }
  734.                                                                                                    else if(eval("\x01") == 525)
  735.                                                                                                    {
  736.                                                                                                       set("\x01",eval("\x01") - 276);
  737.                                                                                                    }
  738.                                                                                                    else if(eval("\x01") == 550)
  739.                                                                                                    {
  740.                                                                                                       set("\x01",eval("\x01") + 26);
  741.                                                                                                    }
  742.                                                                                                    else if(eval("\x01") == 741)
  743.                                                                                                    {
  744.                                                                                                       set("\x01",eval("\x01") - 155);
  745.                                                                                                       ┬º┬ºpush(true);
  746.                                                                                                    }
  747.                                                                                                    else if(eval("\x01") == 560)
  748.                                                                                                    {
  749.                                                                                                       set("\x01",eval("\x01") - 537);
  750.                                                                                                    }
  751.                                                                                                    else
  752.                                                                                                    {
  753.                                                                                                       if(eval("\x01") == 586)
  754.                                                                                                       {
  755.                                                                                                          set("\x01",eval("\x01") + 294);
  756.                                                                                                          if(!┬º┬ºpop())
  757.                                                                                                          {
  758.                                                                                                             continue loop10;
  759.                                                                                                          }
  760.                                                                                                          continue loop9;
  761.                                                                                                       }
  762.                                                                                                       if(eval("\x01") == 991)
  763.                                                                                                       {
  764.                                                                                                          set("\x01",eval("\x01") - 846);
  765.                                                                                                       }
  766.                                                                                                       else if(eval("\x01") == 292)
  767.                                                                                                       {
  768.                                                                                                          set("\x01",eval("\x01") + 495);
  769.                                                                                                       }
  770.                                                                                                       else if(eval("\x01") == 314)
  771.                                                                                                       {
  772.                                                                                                          set("\x01",eval("\x01") + 473);
  773.                                                                                                       }
  774.                                                                                                       else if(eval("\x01") == 787)
  775.                                                                                                       {
  776.                                                                                                          set("\x01",eval("\x01") + 173);
  777.                                                                                                          ┬º┬ºpush(true);
  778.                                                                                                       }
  779.                                                                                                       else if(eval("\x01") == 980)
  780.                                                                                                       {
  781.                                                                                                          set("\x01",eval("\x01") - 670);
  782.                                                                                                          if(┬º┬ºpop())
  783.                                                                                                          {
  784.                                                                                                             set("\x01",eval("\x01") - 103);
  785.                                                                                                          }
  786.                                                                                                       }
  787.                                                                                                       else if(eval("\x01") == 948)
  788.                                                                                                       {
  789.                                                                                                          set("\x01",eval("\x01") - 548);
  790.                                                                                                          if(┬º┬ºpop())
  791.                                                                                                          {
  792.                                                                                                             set("\x01",eval("\x01") + 578);
  793.                                                                                                          }
  794.                                                                                                       }
  795.                                                                                                       else if(eval("\x01") == 120)
  796.                                                                                                       {
  797.                                                                                                          set("\x01",eval("\x01") + 456);
  798.                                                                                                       }
  799.                                                                                                       else
  800.                                                                                                       {
  801.                                                                                                          if(eval("\x01") == 310)
  802.                                                                                                          {
  803.                                                                                                             set("\x01",eval("\x01") - 103);
  804.                                                                                                             break loop0;
  805.                                                                                                          }
  806.                                                                                                          if(eval("\x01") == 207)
  807.                                                                                                          {
  808.                                                                                                             set("\x01",eval("\x01") - 184);
  809.                                                                                                          }
  810.                                                                                                          else if(eval("\x01") == 581)
  811.                                                                                                          {
  812.                                                                                                             set("\x01",eval("\x01") + 347);
  813.                                                                                                             if(┬º┬ºpop())
  814.                                                                                                             {
  815.                                                                                                                set("\x01",eval("\x01") - 881);
  816.                                                                                                             }
  817.                                                                                                          }
  818.                                                                                                          else if(eval("\x01") == 576)
  819.                                                                                                          {
  820.                                                                                                             set("\x01",eval("\x01") + 5);
  821.                                                                                                             ┬º┬ºpush(true);
  822.                                                                                                          }
  823.                                                                                                          else
  824.                                                                                                          {
  825.                                                                                                             if(eval("\x01") != 23)
  826.                                                                                                             {
  827.                                                                                                                if(eval("\x01") == 48)
  828.                                                                                                                {
  829.                                                                                                                   set("\x01",eval("\x01") - 48);
  830.                                                                                                                }
  831.                                                                                                                break loop0;
  832.                                                                                                             }
  833.                                                                                                             set("\x01",eval("\x01") + 925);
  834.                                                                                                             ┬º┬ºpush(true);
  835.                                                                                                          }
  836.                                                                                                       }
  837.                                                                                                    }
  838.                                                                                                 }
  839.                                                                                              }
  840.                                                                                           }
  841.                                                                                        }
  842.                                                                                     }
  843.                                                                                     set("\x01",eval("\x01") - 154);
  844.                                                                                     throw getProperty(┬º┬ºpop(), _X);
  845.                                                                                  }
  846.                                                                                  set("\x01",eval("\x01") - 267);
  847.                                                                                  break loop0;
  848.                                                                               }
  849.                                                                            }
  850.                                                                         }
  851.                                                                      }
  852.                                                                      set("\x01",eval("\x01") + 547);
  853.                                                                      break loop0;
  854.                                                                   }
  855.                                                                   if(eval("\x01") != 293)
  856.                                                                   {
  857.                                                                      if(eval("\x01") == 922)
  858.                                                                      {
  859.                                                                         set("\x01",eval("\x01") + 69);
  860.                                                                         if(┬º┬ºpop())
  861.                                                                         {
  862.                                                                            set("\x01",eval("\x01") - 223);
  863.                                                                         }
  864.                                                                         continue;
  865.                                                                      }
  866.                                                                      if(eval("\x01") == 690)
  867.                                                                      {
  868.                                                                         set("\x01",eval("\x01") - 397);
  869.                                                                         break loop0;
  870.                                                                      }
  871.                                                                      if(eval("\x01") == 199)
  872.                                                                      {
  873.                                                                         set("\x01",eval("\x01") + 729);
  874.                                                                         continue;
  875.                                                                      }
  876.                                                                      if(eval("\x01") != 652)
  877.                                                                      {
  878.                                                                         if(eval("\x01") == 769)
  879.                                                                         {
  880.                                                                            set("\x01",eval("\x01") - 634);
  881.                                                                            ┬º┬ºpush(true);
  882.                                                                         }
  883.                                                                         else
  884.                                                                         {
  885.                                                                            if(eval("\x01") == 124)
  886.                                                                            {
  887.                                                                               set("\x01",eval("\x01") - 62);
  888.                                                                               stop();
  889.                                                                               break loop0;
  890.                                                                            }
  891.                                                                            if(eval("\x01") == 725)
  892.                                                                            {
  893.                                                                               set("\x01",eval("\x01") - 439);
  894.                                                                               if(┬º┬ºpop())
  895.                                                                               {
  896.                                                                                  set("\x01",eval("\x01") + 441);
  897.                                                                               }
  898.                                                                            }
  899.                                                                            else if(eval("\x01") == 772)
  900.                                                                            {
  901.                                                                               set("\x01",eval("\x01") - 499);
  902.                                                                            }
  903.                                                                            else if(eval("\x01") == 768)
  904.                                                                            {
  905.                                                                               set("\x01",eval("\x01") - 453);
  906.                                                                            }
  907.                                                                            else if(eval("\x01") == 135)
  908.                                                                            {
  909.                                                                               set("\x01",eval("\x01") - 38);
  910.                                                                               if(┬º┬ºpop())
  911.                                                                               {
  912.                                                                                  set("\x01",eval("\x01") + 602);
  913.                                                                               }
  914.                                                                            }
  915.                                                                            else if(eval("\x01") == 851)
  916.                                                                            {
  917.                                                                               set("\x01",eval("\x01") - 460);
  918.                                                                               ┬º┬ºpush(true);
  919.                                                                            }
  920.                                                                            else if(eval("\x01") == 656)
  921.                                                                            {
  922.                                                                               set("\x01",eval("\x01") - 562);
  923.                                                                               if(┬º┬ºpop())
  924.                                                                               {
  925.                                                                                  set("\x01",eval("\x01") - 26);
  926.                                                                               }
  927.                                                                            }
  928.                                                                            else if(eval("\x01") == 948)
  929.                                                                            {
  930.                                                                               set("\x01",eval("\x01") - 179);
  931.                                                                            }
  932.                                                                            else if(eval("\x01") == 62)
  933.                                                                            {
  934.                                                                               set("\x01",eval("\x01") + 707);
  935.                                                                            }
  936.                                                                            else
  937.                                                                            {
  938.                                                                               if(eval("\x01") == 510)
  939.                                                                               {
  940.                                                                                  set("\x01",eval("\x01") - 248);
  941.                                                                                  ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  942.                                                                                  break loop0;
  943.                                                                               }
  944.                                                                               if(eval("\x01") == 692)
  945.                                                                               {
  946.                                                                                  set("\x01",eval("\x01") - 692);
  947.                                                                                  break loop0;
  948.                                                                               }
  949.                                                                               if(eval("\x01") == 316)
  950.                                                                               {
  951.                                                                                  set("\x01",eval("\x01") + 374);
  952.                                                                                  if(┬º┬ºpop())
  953.                                                                                  {
  954.                                                                                     set("\x01",eval("\x01") - 397);
  955.                                                                                  }
  956.                                                                               }
  957.                                                                               else
  958.                                                                               {
  959.                                                                                  if(eval("\x01") != 789)
  960.                                                                                  {
  961.                                                                                     break loop0;
  962.                                                                                  }
  963.                                                                                  set("\x01",eval("\x01") - 473);
  964.                                                                                  ┬º┬ºpush(true);
  965.                                                                               }
  966.                                                                            }
  967.                                                                         }
  968.                                                                         continue;
  969.                                                                      }
  970.                                                                      set("\x01",eval("\x01") - 453);
  971.                                                                      eval(┬º┬ºpop())["\x1b/{invalid_utf8=234}{invalid_utf8=209}{invalid_utf8=51}{invalid_utf8=187}"]["╪╡╫å\x1c{invalid_utf8=168}r("]();
  972.                                                                   }
  973.                                                                   set("\x01",eval("\x01") + 558);
  974.                                                                   continue;
  975.                                                                   Ap[┬º┬ºconstant(5)]["╪╡╫å\x1c{invalid_utf8=168}r("](".{invalid_utf8=235}\x0f{invalid_utf8=197}j╔à`");
  976.                                                                   Ap[┬º┬ºconstant(6)]["╪╡╫å\x1c{invalid_utf8=168}r("](".{invalid_utf8=235}\x0f{invalid_utf8=197}j╔à`");
  977.                                                                   Ap[┬º┬ºconstant(7)]();
  978.                                                                   break loop0;
  979.                                                                }
  980.                                                                set("\x01",eval("\x01") + 144);
  981.                                                                if(┬º┬ºpop())
  982.                                                                {
  983.                                                                   set("\x01",eval("\x01") - 453);
  984.                                                                }
  985.                                                             }
  986.                                                          }
  987.                                                       }
  988.                                                    }
  989.                                                 }
  990.                                              }
  991.                                              set("\x01",eval("\x01") - 223);
  992.                                              break loop0;
  993.                                           }
  994.                                           if(eval("\x01") == 276)
  995.                                           {
  996.                                              set("\x01",eval("\x01") - 248);
  997.                                              if(┬º┬ºpop())
  998.                                              {
  999.                                                 set("\x01",eval("\x01") + 296);
  1000.                                              }
  1001.                                           }
  1002.                                           else if(eval("\x01") == 424)
  1003.                                           {
  1004.                                              set("\x01",eval("\x01") - 148);
  1005.                                              ┬º┬ºpush(true);
  1006.                                           }
  1007.                                           else if(eval("\x01") == 770)
  1008.                                           {
  1009.                                              set("\x01",eval("\x01") - 346);
  1010.                                           }
  1011.                                           else
  1012.                                           {
  1013.                                              if(eval("\x01") == 84)
  1014.                                              {
  1015.                                                 break;
  1016.                                              }
  1017.                                              if(eval("\x01") == 926)
  1018.                                              {
  1019.                                                 set("\x01",eval("\x01") - 805);
  1020.                                              }
  1021.                                              else
  1022.                                              {
  1023.                                                 if(eval("\x01") != 347)
  1024.                                                 {
  1025.                                                    if(eval("\x01") == 173)
  1026.                                                    {
  1027.                                                       set("\x01",eval("\x01") + 174);
  1028.                                                    }
  1029.                                                    break loop0;
  1030.                                                 }
  1031.                                                 set("\x01",eval("\x01") - 226);
  1032.                                              }
  1033.                                           }
  1034.                                        }
  1035.                                     }
  1036.                                  }
  1037.                               }
  1038.                            }
  1039.                         }
  1040.                      }
  1041.                   }
  1042.                }
  1043.                set("\x01",eval("\x01") + 30);
  1044.                prevFrame();
  1045.                ┬º┬ºpush(┬º┬ºpop().substr(┬º┬ºpop(),┬º┬ºpop() and ┬º┬ºpop()));
  1046.                break loop0;
  1047.             }
  1048.             if(eval("\x01") == 797)
  1049.             {
  1050.                set("\x01",eval("\x01") - 640);
  1051.                ┬º┬ºpush(true);
  1052.             }
  1053.             else if(eval("\x01") == 157)
  1054.             {
  1055.                set("\x01",eval("\x01") - 120);
  1056.                if(┬º┬ºpop())
  1057.                {
  1058.                   set("\x01",eval("\x01") + 9);
  1059.                }
  1060.             }
  1061.             else
  1062.             {
  1063.                if(eval("\x01") != 681)
  1064.                {
  1065.                   if(eval("\x01") == 133)
  1066.                   {
  1067.                      set("\x01",eval("\x01") - 133);
  1068.                   }
  1069.                   break loop0;
  1070.                }
  1071.                set("\x01",eval("\x01") + 166);
  1072.             }
  1073.          }
  1074.          while(true)
  1075.          {
  1076.             if(eval("\x01") == 279)
  1077.             {
  1078.                set("\x01",eval("\x01") + 440);
  1079.                ┬º┬ºpush(true);
  1080.             }
  1081.             else if(eval("\x01") == 243)
  1082.             {
  1083.                set("\x01",eval("\x01") + 211);
  1084.             }
  1085.             else if(eval("\x01") == 244)
  1086.             {
  1087.                set("\x01",eval("\x01") + 380);
  1088.             }
  1089.             else if(eval("\x01") == 770)
  1090.             {
  1091.                set("\x01",eval("\x01") - 465);
  1092.                if(┬º┬ºpop())
  1093.                {
  1094.                   set("\x01",eval("\x01") - 62);
  1095.                }
  1096.             }
  1097.             else if(eval("\x01") == 624)
  1098.             {
  1099.                set("\x01",eval("\x01") - 176);
  1100.                ┬º┬ºpush(true);
  1101.             }
  1102.             else
  1103.             {
  1104.                if(eval("\x01") == 305)
  1105.                {
  1106.                   set("\x01",eval("\x01") - 62);
  1107.                   return ┬º┬ºpop();
  1108.                }
  1109.                if(eval("\x01") == 679)
  1110.                {
  1111.                   set("\x01",eval("\x01") + 118);
  1112.                }
  1113.                else if(eval("\x01") == 37)
  1114.                {
  1115.                   set("\x01",eval("\x01") + 176);
  1116.                   set("\t",26);
  1117.                }
  1118.                else
  1119.                {
  1120.                   if(eval("\x01") == 646)
  1121.                   {
  1122.                      set("\x01",eval("\x01") + 331);
  1123.                      break loop0;
  1124.                   }
  1125.                   if(eval("\x01") == 682)
  1126.                   {
  1127.                      set("\x01",eval("\x01") - 60);
  1128.                      ┬º┬ºpush(true);
  1129.                   }
  1130.                   else if(eval("\x01") == 924)
  1131.                   {
  1132.                      set("\x01",eval("\x01") - 154);
  1133.                      ┬º┬ºpush(true);
  1134.                   }
  1135.                   else if(eval("\x01") == 719)
  1136.                   {
  1137.                      set("\x01",eval("\x01") - 328);
  1138.                      if(┬º┬ºpop())
  1139.                      {
  1140.                         set("\x01",eval("\x01") - 376);
  1141.                      }
  1142.                   }
  1143.                   else if(eval("\x01") == 977)
  1144.                   {
  1145.                      set("\x01",eval("\x01") - 53);
  1146.                   }
  1147.                   else if(eval("\x01") == 46)
  1148.                   {
  1149.                      set("\x01",eval("\x01") + 635);
  1150.                   }
  1151.                   else
  1152.                   {
  1153.                      if(eval("\x01") == 391)
  1154.                      {
  1155.                         set("\x01",eval("\x01") - 376);
  1156.                         break loop0;
  1157.                      }
  1158.                      if(eval("\x01") == 625)
  1159.                      {
  1160.                         set("\x01",eval("\x01") + 172);
  1161.                      }
  1162.                      else if(eval("\x01") == 955)
  1163.                      {
  1164.                         set("\x01",eval("\x01") - 31);
  1165.                      }
  1166.                      else if(eval("\x01") == 724)
  1167.                      {
  1168.                         set("\x01",eval("\x01") - 42);
  1169.                      }
  1170.                      else if(eval("\x01") == 487)
  1171.                      {
  1172.                         set("\x01",eval("\x01") + 194);
  1173.                      }
  1174.                      else
  1175.                      {
  1176.                         if(eval("\x01") == 847)
  1177.                         {
  1178.                            set("\x01",eval("\x01") - 714);
  1179.                            eval("3\\~{invalid_utf8=151}{invalid_utf8=197}P{invalid_utf8=245}")["g{invalid_utf8=186}{invalid_utf8=206}{"] -= 2;
  1180.                            break loop0;
  1181.                         }
  1182.                         if(eval("\x01") == 976)
  1183.                         {
  1184.                            set("\x01",eval("\x01") - 252);
  1185.                            break loop0;
  1186.                         }
  1187.                         if(eval("\x01") == 622)
  1188.                         {
  1189.                            set("\x01",eval("\x01") + 24);
  1190.                            if(┬º┬ºpop())
  1191.                            {
  1192.                               set("\x01",eval("\x01") + 331);
  1193.                            }
  1194.                         }
  1195.                         else if(eval("\x01") == 213)
  1196.                         {
  1197.                            set("\x01",eval("\x01") + 241);
  1198.                            if(eval("\t") == 26)
  1199.                            {
  1200.                               ┬º┬ºpush(┬º┬ºpop() == targetPath(┬º┬ºpop() gt ┬º┬ºpop()));
  1201.                               break loop0;
  1202.                            }
  1203.                         }
  1204.                         else if(eval("\x01") == 937)
  1205.                         {
  1206.                            set("\x01",eval("\x01") - 255);
  1207.                         }
  1208.                         else if(eval("\x01") == 757)
  1209.                         {
  1210.                            set("\x01",eval("\x01") + 219);
  1211.                            if(┬º┬ºpop())
  1212.                            {
  1213.                               set("\x01",eval("\x01") - 252);
  1214.                            }
  1215.                         }
  1216.                         else if(eval("\x01") == 929)
  1217.                         {
  1218.                            set("\x01",eval("\x01") - 457);
  1219.                            if(┬º┬ºpop())
  1220.                            {
  1221.                               set("\x01",eval("\x01") - 228);
  1222.                            }
  1223.                         }
  1224.                         else if(eval("\x01") == 15)
  1225.                         {
  1226.                            set("\x01",eval("\x01") + 84);
  1227.                         }
  1228.                         else
  1229.                         {
  1230.                            if(eval("\x01") == 472)
  1231.                            {
  1232.                               set("\x01",eval("\x01") - 228);
  1233.                               break loop0;
  1234.                            }
  1235.                            if(eval("\x01") != 884)
  1236.                            {
  1237.                               break;
  1238.                            }
  1239.                            set("\x01",eval("\x01") - 260);
  1240.                         }
  1241.                      }
  1242.                   }
  1243.                }
  1244.             }
  1245.          }
  1246.       }
  1247.    }
  1248. }
  1249.